     Introducing an exciting new program for adults, students
     and teachers which is both FUN and EDUCATIONAL.

     Finally, a program which makes it easy and fun for
     everyone to make their own animated computer games
     while learning the concepts of programming.

     Computer teachers: Now your students will want to learn
     programming as they create their own distinctive games!

*************************************************************
***                      "GAMEBASIC"                      ***
*************************************************************

    CONTENTS
    ---------

1.  WHAT IS GAMEBASIC?
2.  HOW DO YOU MAKE GAMES WITH GAMEBASIC?
3.  GAMEBASIC ROUTINES
4.  GAMEBASIC SYSTEM REQUIREMENTS
5.  LEGAL NOTICE
6.  WHAT DOES GAMEBASIC COST AND HOW DO I ORDER IT?



    The following is a brief outline of GameBasic's features.
    Complete instructions on Introductory Programming and how
    to use GameBasic can be found in the GameBasic manual,
    GBMANUAL.TXT accompanying this software release.


-----------------------------------------------------------
1.  WHAT IS GAMEBASIC ?

-----------------------------------------------------------

     GAMEBASIC is a program which enables students to create
     their own exciting animated computer games incorporating
     both sound and colour, using very simple commands in
     Basic.

     The objective of GAMEBASIC is to make it FUN to learn
     computers and Basic programming as students create their
     own exciting fast-action computer games.  As shown by the
     demonstration games, the only limitation to the types of
     games that can be easily created by GameBasic is the
     student's imagination.

     GAMEBASIC is supported by a 170 page instruction manual
     which explains to students in simple terms the Basic
     programming environment, programming concepts (using
     games as examples), and takes them through the
     development of a sophisticated game step-by-step,
     progressively introducing each GAMEBASIC function.
     Running examples of all code are included.

     With GAMEBASIC, students can develop their own versions
     of games like Alien Invaders, HackMan, Racquet-Ball,
     Question and Answer games with animation, and two-player
     keyboard games like Tank Battle.

     Run program GBDEMO.EXE  to see examples of the types of
     games that GAMEBASIC can create. The GameBasic code
     for these games is included in file GBCODE.TXT,
     which includes a version of Alien Invaders that
     was coded in only 57 instructions (to demonstrate the
     POWER of GAMEBASIC!)




     ---------------------------------------------------------
2.   HOW DO YOU MAKE GAMES WITH GAMEBASIC ?
     ---------------------------------------------------------

     GAMEBASIC has been developed using the concept of
     SPRITES.  A SPRITE is a graphic-character (maybe a
     spaceship or an alien) that students define to GAMEBASIC.
     Once they have defined their sprites, and told GAMEBASIC
     where to put them and how they move, GAMEBASIC then
     handles all the movement for them, thus allowing them to
     concentrate on the logic of their game rather than the
     technical complexities of moving graphical characters in
     Basic.

     GAMEBASIC comes with many powerful routines that make
     programming sophisticated games very easy.

     A game character in GAMEBASIC is defined in a 16 by 12
     array. The following is the GameBasic definition for the
     cannon used in the Alien Invaders demonstration game:

     char$(1, 1) = "                "
     char$(1, 2) = "                "
     char$(1, 3) = "
     char$(1, 4) = "                "
     char$(1, 5) = "        F       "
     char$(1, 6) = "        F       "
     char$(1, 7) = "       3F3      "
     char$(1, 8) = " 33333333333333 "
     char$(1, 9) = "33  3 3 3 3 3 33"
     char$(1,10) = "3333333333333333"
     char$(1,11) = "  6 6      6 6  "
     char$(1,12) = "   6        6   "

     Numbers 0 to 9 and letters A to F represent different
     coloured pixels; the colour for each number or letter can

     be user-defined from over 262,000 colours.  There can be
     up to 20 different characters in any one game.
     (THE DEMONSTRATION VERSION OF GAMEBASIC ONLY ALLOWS 5
     CHARACTERS TO BE DEFINED - THIS IS THE ONLY LIMITATION,
     ALL OTHER FEATURES AND FUNCTIONS ARE THE SAME AS THE
     FULL VERSION)

     GAMEBASIC allows up to 90 SPRITES in a game. A sprite is
     created using one of the 20 characters that have been
     defined. One single character definition can be used
     to create multiple sprites. For example, if character
     #1 was a space-alien character, that one character
     definition could be used to create 30 alien sprites
     coming down the screen.


     You create sprites by using CREATE command.
     This command assigns a "sprite number" to the sprite,
     tells GAMEBASIC which character to display the sprite as,
     and puts it on the screen at the row and column you
     specify. The CREATE command also tells GAMEBASIC what
     speed and in which direction the sprite should move, as
     well as what should happen to the Sprite when it hits a
     screen border - ie the top, bottom or either side of the
     screen.
     When it hits a screen border, you have the following
     options:
          a) The sprite can wrap around the screen
          b) The sprite can be deleted.
          c) The sprite can stay where it is.
          d) The sprite can bounce off the edge, like a ball.

     GAMEBASIC's CONTROL command defines which Sprite
     numbers are controlled by the keyboard, whether they can
     move up, down, left or right, which keys will move them
     in a particular direction and,  when a "Fire" key is
     pressed,  what character should be fired (maybe a missile
     you've defined) and in which direction. This is a very
     powerful command, saving you a lot of programming time.

     GAMEBASIC's CHECKHIT command is used to check if one
     Sprite has hit another one, or one of a range of Sprites.
     For example, one CHECKHIT instruction could be used to
     see if a Missile sprite has hit any of our 30 invading
     Aliens!

     Using GAMEBASIC's SHOOT command, your program can
     literally shoot a specific Character from one Sprite to
     another Sprite at a given speed. This is used in some of
     the demonstration games where the Aliens are firing
     fireballs directly at the cannon.

     There are many other powerful GAMEBASIC routines that
     come with the system.  Each of them is outlined in detail
     below.






-------------------------------------------------------------
3.  GAMEBASIC ROUTINES

-------------------------------------------------------------


     CALL  CREATE          (sprite.no,  char.no,  col,  row,
                         speed, pixspermove, direction,
                         horiz$,  vert$, track.no)

          Use the CREATE command to create a sprite in your
          game. You tell GAMEBASIC which character the sprite
          should be displayed as, where it should be initially
          placed on the screen, what speed and in which
          direction it should move, what should happen to the
          sprite when it reaches a screen border and whether
          it is a sprite that should follow a track that's
          been laid down (see TRACK command later).



     CALL CONTROL (sprite.no, horiz$, vert$, pixspermove,
"u", keyup,   charup,   shootdirectup,   shootcharup,
"d", keydown, chardown, shootdirectdown, shootchardown,
"l", keyleft, charleft, shootdirectleft, shootcharleft,
"r", keyright,charright,shootdirectright,shootcharright)

          This command tells GAMEBASIC that a specific sprite
          number is to be controlled by the keyboard. For that
          sprite number, it also tells GAMEBASIC whether the
          sprite can move horizontally and/or vertically, the
          number of pixels it should move each time, which
          keys control the sprite movement, the character the
          sprite should be shown as when it's moving in a
          particular direction (ie a spaceship pointing up the
          screen as opposed to pointing to the left) and, when
          the SHOOT command is issued for this sprite (see
          next), which character to shoot (ie a missile
          pointing up rather than a missile pointing to the
          left) and in which direction it should move.



     CALL SHOOT     (sprite.no, charno, from.spriteno,
            to.spriteno, speed, pixspermove, horiz$, vert$)

          When this command is issued, a sprite is created
          using the character number in charno, starting at
          the location of the sprite referenced in
          from.spriteno aimed towards the sprite referenced in
          to.spriteno at the given speed  and pixelspermove.
          If the from.spriteno is a keyboard-controlled sprite
          (like a cannon) and to.sprite is entered as 0
          (zero), then the direction for the shoot sprite to
          move in will be taken from the CALL CONTROL
          parameters coded.


     CALL  ACTIVE     ( sprite.no1, sprite.no2, return-value)

          This is a GAMEBASIC command that will tell us
          whether one or more sprites are currently active on
          the screen. Return value will contain the total
          number of active sprites in the range specified.



     CALL  CHECKHIT   (sprite.no,   target.sprite1,
          target.sprite2,tolerance, return-value)

          CHECKHIT tells us if a specific sprite has collided
          with any other sprites in our game (ie has a missile
          hit an alien?). Non-moving sprites, like rocks or
          land mines, will be checked if they fall within the
          sprite number range you specify. Non-active sprites
          (ie sprites that  have previously been deleted) will
          be ignored. You can check if
               a) One sprite has hit one other sprite
               b) One sprite has hit any of a range of sprites
               c) One sprite has hit ANY other sprite.

          You can specify a tolerance for the check. Return
          value  will contain the first sprite number that has
          hit the  specified sprite.



     CALL   DELETE    (sprite.no1, sprite.no2)

          We use this GAMEBASIC command to delete active
          sprites. You can delete a single sprite or a range
          of  sprites.



     CALL  INFO ( sprite.no, col, row, speed, direction,
          char.no,  hit.edge$, pixspermove)

          This GAMEBASIC command returns information (that
          you may want to use in your program) relating to a
          specific sprite. You can find out what row or column
          the sprite is on, what speed and in which direction
          it is moving, which character it is being displayed
          as and which screen border it has just reached.



     CALL   RAND     ( rand1,  rand2,  return-value )

          The  RAND GAMEBASIC routine will return in the
          variable entered for return-value, a random number
          between the two numbers entered in rand1 and rand2.




     CALL  CHANGECHAR   ( sprite.no,  char.no )

          Use the CHANGECHAR routine to change the character
          that a sprite is being displayed as.



     CALL MOTION    (sprite.no, speed,  direction,
          pixspermove)

          The MOTION command lets us change how a sprite is
          moving. We can change its speed, direction and
          number of pixels per move.



     CALL GETANGLE   ( sprite.no1, sprite.no2,  return-value)

          This command will return the angle between two
          sprites.



     CALL MUSIC    (type$,  length$,  tempo$,  octave$,
                    notes$)

          Introduce a new dimension to your games by adding
          music and sounds. You can specify either a series of
          notes that are continually played while your game is
          playing or a single series of notes that are to be
          played once when a specific condition occurs (for
          example, the launch of a missile).  Single series of
          notes interrupt  continuous sounds.



     CALL TEXTSCREEN   (Screen.mode, Clear.screen$, Choice$)

          Use this GAMEBASIC routine to display a menu or text
          screen from which the player may select a choice.
          The routine uses a GAMEBASIC array called gb.line$()
          which has 25 entries, each entry representing the
          text that you want printed at that line number.
          Before calling TEXTSCREEN, enter all the valid keys
          that the player  can press into the Choice$ variable
          you will be passing to the routine. The routine will
          then check that a valid  key was pressed  before
          returning back to your program.
          To accept ANY key, put a null value ( "" ) in
          Choice$.



     CALL QUESTION   (Question.row,  Question.col,
          Answer.row, Answer.col, Question.no, Result$)

          GAMEBASIC lets you make question and answer
          games very easily, also incorporating animated
          characters to enhance your game. To make these types
          of games, you enter your questions into an array
          called gb.question$, the correct answer into an
          array called gb.answer$, then issue the CALL
          QUESTION command.  You control where on the screen
          the question is asked and where the answer is
          displayed as the player enters it. GAMEBASIC handles
          all keyboard entry of answers. When the player hits
          the enter key, GAMEBASIC checks the answer for you
          and returns a Y or N in Result$.



     CALL TRACK    (Row.or.Col$, start.row.or.col.no,
                    start.no,  end.no, width, track$)

          With GAMEBASIC, you can make sprites follow one of
          7 tracks (tracks A to F - corresponding to colour
          codes A to F;  and track 0 - the background track).
          You lay down TRACKS on the screen by using this
          TRACK routine.  If you want a sprite to follow a
          track then the CALL CREATE command which creates the
          sprite must specify which track it is to follow.
          Tracks can have intersections so that when a sprite
          following a track  comes to a junction, it will
          randomly decide which path to follow.




     CALL COLOUR   (Colour.code$, colour.name$,
                           blue,  green,  red )

          Each colour code used in your character definitions
          (0 to 9 and A to F) can be changed to any of 262,144
          colours by this command.



     CALL DISTANCE   ( sprite.no1, sprite.no2, distance )

          The DISTANCE routine returns the distance in pixels
          between two active sprites.



     CALL PAUSE   ( number )

          The PAUSE routine stops your program for a number of
          seconds.  If you press any key on the keyboard
          before the pause-time has expired, your program will
          start up   again. If you want to stop your program
          indefinitely until any key is pressed, regardless of
          the time, then use  0 for the number.



     CALL COLOURRESET

          COLOURRESET resets all custom colours you have
          defined, including the background colour (0) and
          text-colour (15),  back to their original QBasic
          colours.



     CALL MOVEBACK   ( sprite.no )

          MOVEBACK moves a sprite back to the screen position
          it was in just before its last move.



     CALL PIXELCOLOUR   ( sprite.no, top.left, top.right,
                       bottom.left, bottom.right)

          The PIXELCOLOUR routine returns the colour codes of
          the pixels at the four extreme corners of the
          specified sprite on the screen.





     MISCELLANEOUS GAMEBASIC FEATURES
     --------------------------------

     SCREEN MODES :  GAMEBASIC allows games to be
          programmed in two screen modes - mode 1 and 2.

          In screen mode 1, you define characters 16 pixels
          wide and 12 pixels deep. In screen mode 2 your
          characters  will be about the same size as in mode
          1, but you get better  character definition since
          your characters can be 32  pixels wide and 30 deep.
          However, game speed will be  slightly slower.



     SPLIT-SCREEN FEATURE.  With GAMEBASIC, you can
          program your game so that specific sprites only move
          within certain screen boundaries.

          Set GAMEBASIC variables gb.screen.start.row,
          gb.screen.start.col, gb.screen.end.row  and
          gb.screen.end.col to be the screen limits you want
          before creating the sprites that should move within
          these  limits.

          Any sprites you CREATE after these variables have
          been set will then wrap, stay or bounce etc.. within
          these limits. Using this feature, you can program a
          two-player game where each player plays in his own
          "window" with his own sprites.




-------------------------------------------------------------
4.   GAMEBASIC SYSTEM REQUIREMENTS

--------------------------------------------------------------


     To run GAMEBASIC you must have the following:

     a)   QBasic  (QBasic comes with DOS versions 5 and higher
               and will be found in your DOS directory).

     b)   a 386 computer or better  (GAMEBASIC will run on 286
                computers, but game speed may not be
                    satisfactory)

     c)  VGA monitor

     d)  Hard disk drive with 2.0 megabytes free.

     -------------
5.   LEGAL NOTICE
     -------------

     THIS DEMONSTRATION VERSION OF GAMEBASIC IS
     DISTRIBUTED FOR REVIEW PURPOSES ONLY.
     YOU ARE HEREBY GRANTED THE RIGHT TO USE ONE COPY OF
     GAMEBASIC ON A SINGLE TERMINAL CONNECTED TO A SINGLE
     COMPUTER. YOU MAY NOT NETWORK GAMEBASIC OR OTHERWISE
     INSTALL IT ON MORE THAN ONE COMPUTER OR COMPUTER TERMINAL
     AT ANY ONE TIME WITHOUT PURCHASING APPROPRIATE LICENSES.



--------------------------------------------------------------

6.   WHAT DOES GAMEBASIC COST AND HOW DO I ORDER IT ?

--------------------------------------------------------------

     The full version of GAMEBASIC, which allows you to define
     up to 20 different characters in your games and enables
     you to receive all new releases of the product, costs $20
     US or $28 Cdn.

     Volume discounts are available for educational
     institutions. Please contact address below or Email to
     mwatts@interlog.com

     To order GameBasic, please send a cheque or money order
     made payable to M. R. Watts to :

     GameBasic, Dept I01
     703 Edgewood Road,
     Pickering,
     ONTARIO, L1V 2Z5
     CANADA

     YOU MUST INCLUDE YOUR INTERNET EMAIL ADDRESS WITH YOUR
     PAYMENT.

     Upon receipt, we will Email you the password which will
     enable you to download the full version from our web
     site at www.interlog.com/~mwatts/gamebasic

